/**
 * 服务模块的Vuex状态管理
 * @module store/modules/service
 * @author 互成一家
 * @description 服务模块的状态管理，包含服务列表、详情、评价等
 */
import * as serviceApi from '@/api/service';
import { 
  serviceList, 
  serviceCategories, 
  serviceReviews,
  SERVICE_RATING
} from '@/mock/service';
import { USE_MOCK } from '@/api/config';

/**
 * 状态定义
 * @typedef {Object} ServiceState
 * @property {Array} categories - 服务分类列表
 * @property {Array} serviceList - 服务列表
 * @property {Object|null} currentService - 当前选中的服务
 * @property {Array} reviews - 评价列表
 * @property {Boolean} loadingCategories - 是否正在加载分类
 * @property {Boolean} loadingServiceList - 是否正在加载服务列表
 * @property {Boolean} loadingServiceDetail - 是否正在加载服务详情
 * @property {Boolean} loadingReviews - 是否正在加载评价
 * @property {Object} pagination - 分页信息
 */
const state = {
  /** 服务分类列表 */
  categories: [],
  /** 服务列表 */
  serviceList: [],
  /** 当前选中的服务 */
  currentService: null,
  /** 评价列表 */
  reviews: [],
  /** 是否正在加载分类 */
  loadingCategories: false,
  /** 是否正在加载服务列表 */
  loadingServiceList: false,
  /** 是否正在加载服务详情 */
  loadingServiceDetail: false,
  /** 是否正在加载评价 */
  loadingReviews: false,
  /** 分页信息 */
  pagination: {
    current: 1,
    pageSize: 10,
    total: 0
  }
};

/**
 * 变更方法
 * @type {Object}
 */
const mutations = {
  /**
   * 设置服务分类列表
   * @param {ServiceState} state - 状态
   * @param {Array} categories - 分类列表
   */
  SET_CATEGORIES(state, categories) {
    state.categories = categories;
  },
  
  /**
   * 设置服务列表
   * @param {ServiceState} state - 状态
   * @param {Array} services - 服务列表
   */
  SET_SERVICE_LIST(state, services) {
    state.serviceList = services;
  },
  
  /**
   * 设置当前服务
   * @param {ServiceState} state - 状态
   * @param {Object} service - 服务对象
   */
  SET_CURRENT_SERVICE(state, service) {
    state.currentService = service;
  },
  
  /**
   * 设置评价列表
   * @param {ServiceState} state - 状态
   * @param {Array} reviews - 评价列表
   */
  SET_REVIEWS(state, reviews) {
    state.reviews = reviews;
  },
  
  /**
   * 添加评价
   * @param {ServiceState} state - 状态
   * @param {Object} review - 评价对象
   */
  ADD_REVIEW(state, review) {
    state.reviews.unshift(review);
    // 更新当前服务的评价数量和评分
    if (state.currentService && state.currentService.id === review.serviceId) {
      state.currentService.reviewCount = (state.currentService.reviewCount || 0) + 1;
      // 重新计算平均评分
      const totalRating = state.reviews.reduce((sum, r) => sum + r.rating, 0);
      state.currentService.rating = parseFloat((totalRating / state.reviews.length).toFixed(1));
    }
  },
  
  /**
   * 设置分类加载状态
   * @param {ServiceState} state - 状态
   * @param {Boolean} loading - 是否加载中
   */
  SET_LOADING_CATEGORIES(state, loading) {
    state.loadingCategories = loading;
  },
  
  /**
   * 设置服务列表加载状态
   * @param {ServiceState} state - 状态
   * @param {Boolean} loading - 是否加载中
   */
  SET_LOADING_SERVICE_LIST(state, loading) {
    state.loadingServiceList = loading;
  },
  
  /**
   * 设置服务详情加载状态
   * @param {ServiceState} state - 状态
   * @param {Boolean} loading - 是否加载中
   */
  SET_LOADING_SERVICE_DETAIL(state, loading) {
    state.loadingServiceDetail = loading;
  },
  
  /**
   * 设置评价加载状态
   * @param {ServiceState} state - 状态
   * @param {Boolean} loading - 是否加载中
   */
  SET_LOADING_REVIEWS(state, loading) {
    state.loadingReviews = loading;
  },
  
  /**
   * 设置分页信息
   * @param {ServiceState} state - 状态
   * @param {Object} pagination - 分页信息
   */
  SET_PAGINATION(state, pagination) {
    state.pagination = {
      ...state.pagination,
      ...pagination
    };
  }
};

/**
 * actions 操作方法
 * @type {Object}
 */
const actions = {
  /**
   * 获取服务分类列表
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @returns {Promise<void>}
   */
  async fetchCategories({ commit }) {
    commit('SET_LOADING_CATEGORIES', true);
    try {
      const res = await serviceApi.getServiceCategories();
      
      if (res.code === 0) {
        commit('SET_CATEGORIES', res.data);
      } else {
        uni.showToast({
          title: res.message || '获取服务分类失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('获取服务分类失败', error);
      uni.showToast({
        title: '获取服务分类失败',
        icon: 'none'
      });
    } finally {
      commit('SET_LOADING_CATEGORIES', false);
    }
  },
  
  /**
   * 获取服务列表
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @param {Object} params - 查询参数
   * @param {Number|String} [params.categoryId] - 分类ID
   * @param {String} [params.keyword] - 搜索关键词
   * @param {Number} [params.page=1] - 页码
   * @param {Number} [params.pageSize=10] - 每页条数
   * @returns {Promise<void>}
   */
  async fetchServiceList({ commit }, params = {}) {
    commit('SET_LOADING_SERVICE_LIST', true);
    try {
      const res = await serviceApi.getServiceList(params);
      
      if (res.code === 0) {
        commit('SET_SERVICE_LIST', res.data.list || res.data);
        commit('SET_PAGINATION', {
          current: params.page || 1,
          pageSize: params.pageSize || 10,
          total: res.data.total || res.data.length
        });
      } else {
        uni.showToast({
          title: res.message || '获取服务列表失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('获取服务列表失败', error);
      uni.showToast({
        title: '获取服务列表失败',
        icon: 'none'
      });
    } finally {
      commit('SET_LOADING_SERVICE_LIST', false);
    }
  },
  
  /**
   * 获取服务详情
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @param {Number|String} serviceId - 服务ID
   * @returns {Promise<Object>} 服务详情对象
   */
  async fetchServiceDetail({ commit }, serviceId) {
    try {
      console.log('[服务模块] 开始加载服务详情', serviceId);
      commit('SET_LOADING_SERVICE_DETAIL', true);
      
      const res = await serviceApi.getServiceDetail(serviceId);
      
      if (res.code === 0) {
        console.log('[服务模块] 服务详情加载成功:', res.data);
        commit('SET_CURRENT_SERVICE', res.data);
        return res.data;
      } else {
        console.warn('[服务模块] 服务详情加载失败:', res.message);
        uni.showToast({
          title: res.message || '服务信息加载失败',
          icon: 'none'
        });
        
        // 使用模拟数据作为备选
        if (USE_MOCK) {
          console.log('[服务模块] 使用本地模拟数据');
          const mockService = serviceList.find(s => String(s.id) === String(serviceId));
          if (mockService) {
            console.log('[服务模块] 找到本地模拟数据:', mockService);
            commit('SET_CURRENT_SERVICE', mockService);
            return mockService;
          }
        }
        
        return null;
      }
    } catch (error) {
      console.error('[服务模块] 加载服务详情异常', error);
      
      // 发生异常时，尝试使用本地模拟数据
      if (USE_MOCK) {
        console.log('[服务模块] 异常处理: 尝试使用本地模拟数据');
        const mockService = serviceList.find(s => String(s.id) === String(serviceId));
        if (mockService) {
          console.log('[服务模块] 找到本地模拟数据:', mockService);
          commit('SET_CURRENT_SERVICE', mockService);
          return mockService;
        }
      }
      
      uni.showToast({
        title: '服务信息加载失败',
        icon: 'none'
      });
      return null;
    } finally {
      commit('SET_LOADING_SERVICE_DETAIL', false);
    }
  },
  
  /**
   * 获取服务评价列表
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @param {Object} params - 查询参数
   * @param {Number|String} params.serviceId - 服务ID
   * @param {Number} [params.rating] - 评分筛选：0=全部，4=好评，3=中评，1=差评
   * @param {Boolean} [params.hasImage] - 是否有图片
   * @param {Number} [params.page=1] - 页码
   * @param {Number} [params.pageSize=10] - 每页条数
   * @returns {Promise<Array>} 评价数组
   */
  async fetchServiceReviews({ commit }, params) {
    try {
      console.log('[服务模块] 开始加载服务评价', params);
      commit('SET_LOADING_REVIEWS', true);
      
      const res = await serviceApi.getServiceReviews(params);
      
      if (res.code === 0) {
        const { list, pagination } = res.data;
        console.log('[服务模块] 服务评价加载成功', list.length);
        commit('SET_REVIEWS', list);
        commit('SET_PAGINATION', pagination);
        return list;
      } else {
        console.warn('[服务模块] 服务评价加载失败', res.message);
        // 尝试使用本地模拟数据
        if (USE_MOCK && params.serviceId) {
          console.log('[服务模块] 尝试使用本地模拟评价数据');
          const serviceIdStr = String(params.serviceId);
          const mockReviews = serviceReviews[serviceIdStr];
          
          if (mockReviews && mockReviews.length) {
            console.log('[服务模块] 找到本地模拟评价数据', mockReviews.length);
            
            // 简单的分页处理
            const page = params.page || 1;
            const pageSize = params.pageSize || 10;
            const startIndex = (page - 1) * pageSize;
            const endIndex = startIndex + pageSize;
            
            // 简化版的筛选逻辑
            let filteredReviews = [...mockReviews];
            
            // 评分筛选
            if (params.rating) {
              if (params.rating === SERVICE_RATING.GOOD) {
                filteredReviews = filteredReviews.filter(review => review.rating >= 4);
              } else if (params.rating === SERVICE_RATING.MEDIUM) {
                filteredReviews = filteredReviews.filter(review => review.rating === 3);
              } else if (params.rating === SERVICE_RATING.BAD) {
                filteredReviews = filteredReviews.filter(review => review.rating <= 2);
              }
            }
            
            // 是否有图片
            if (params.hasImage) {
              filteredReviews = filteredReviews.filter(review => review.images && review.images.length > 0);
            }
            
            // 分页结果
            const pagedReviews = filteredReviews.slice(startIndex, endIndex);
            
            // 构建分页信息
            const pagination = {
              current: page,
              pageSize: pageSize,
              total: filteredReviews.length
            };
            
            commit('SET_REVIEWS', pagedReviews);
            commit('SET_PAGINATION', pagination);
            return pagedReviews;
          }
        }
        
        uni.showToast({
          title: res.message || '评价加载失败',
          icon: 'none'
        });
        commit('SET_REVIEWS', []);
        return [];
      }
    } catch (error) {
      console.error('[服务模块] 加载评价异常', error);
      
      // 异常处理，尝试使用本地模拟数据
      if (USE_MOCK && params.serviceId) {
        console.log('[服务模块] 异常处理: 尝试使用本地模拟评价数据');
        const mockReviews = serviceReviews[params.serviceId];
        if (mockReviews && mockReviews.length) {
          console.log('[服务模块] 找到本地模拟评价数据');
          commit('SET_REVIEWS', mockReviews.slice(0, params.pageSize || 10));
          commit('SET_PAGINATION', {
            current: 1,
            pageSize: params.pageSize || 10,
            total: mockReviews.length
          });
          return mockReviews.slice(0, params.pageSize || 10);
        }
      }
      
      uni.showToast({
        title: '评价加载失败',
        icon: 'none'
      });
      commit('SET_REVIEWS', []);
      return [];
    } finally {
      commit('SET_LOADING_REVIEWS', false);
    }
  },
  
  /**
   * 提交服务评价
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @param {Object} reviewData - 评价数据
   * @param {Number|String} reviewData.serviceId - 服务ID
   * @param {Number} reviewData.rating - 评分(1-5)
   * @param {String} reviewData.content - 评价内容
   * @param {Array} [reviewData.images] - 图片列表
   * @returns {Promise<Boolean>} 提交结果
   */
  async submitServiceReview({ commit }, reviewData) {
    try {
      const res = await serviceApi.submitServiceReview(reviewData);
      
      if (res.code === 0) {
        // 添加到评价列表
        commit('ADD_REVIEW', res.data.review);
        uni.showToast({
          title: '评价提交成功',
          icon: 'success'
        });
        return true;
      } else {
        uni.showToast({
          title: res.message || '评价提交失败',
          icon: 'none'
        });
        return false;
      }
    } catch (error) {
      console.error('评价提交失败', error);
      uni.showToast({
        title: '评价提交失败',
        icon: 'none'
      });
      return false;
    }
  },
  
  /**
   * 收藏服务
   * @param {Object} context - Vuex上下文
   * @param {Number|String} serviceId - 服务ID
   * @returns {Promise<Boolean>} 收藏结果
   */
  async favoriteService(context, serviceId) {
    try {
      const res = await serviceApi.favoriteService(serviceId);
      
      if (res.code === 0) {
        uni.showToast({
          title: '收藏成功',
          icon: 'success'
        });
        return true;
      } else {
        uni.showToast({
          title: res.message || '收藏失败',
          icon: 'none'
        });
        return false;
      }
    } catch (error) {
      console.error('收藏失败', error);
      uni.showToast({
        title: '收藏失败',
        icon: 'none'
      });
      return false;
    }
  },
  
  /**
   * 取消收藏服务
   * @param {Object} context - Vuex上下文
   * @param {Number|String} serviceId - 服务ID
   * @returns {Promise<Boolean>} 取消收藏结果
   */
  async unfavoriteService(context, serviceId) {
    try {
      const res = await serviceApi.unfavoriteService(serviceId);
      
      if (res.code === 0) {
        uni.showToast({
          title: '已取消收藏',
          icon: 'success'
        });
        return true;
      } else {
        uni.showToast({
          title: res.message || '取消收藏失败',
          icon: 'none'
        });
        return false;
      }
    } catch (error) {
      console.error('取消收藏失败', error);
      uni.showToast({
        title: '取消收藏失败',
        icon: 'none'
      });
      return false;
    }
  },
  
  /**
   * 预约服务
   * @param {Object} context - Vuex上下文
   * @param {Object} bookingData - 预约数据
   * @returns {Promise<Object|Boolean>} 预约结果
   */
  async bookService(context, bookingData) {
    try {
      const res = await serviceApi.bookService(bookingData);
      
      if (res.code === 0) {
        uni.showToast({
          title: '预约成功',
          icon: 'success'
        });
        return res.data;
      } else {
        uni.showToast({
          title: res.message || '预约失败',
          icon: 'none'
        });
        return false;
      }
    } catch (error) {
      console.error('预约失败', error);
      uni.showToast({
        title: '预约失败',
        icon: 'none'
      });
      return false;
    }
  }
};

/**
 * getters计算属性
 * @type {Object}
 */
const getters = {
  /**
   * 按分类ID获取服务列表
   * @param {ServiceState} state - 状态
   * @returns {Function} 返回一个函数，接收分类ID参数返回过滤后的服务列表
   */
  servicesByCategory: (state) => (categoryId) => {
    if (!categoryId || categoryId === 'all') {
      return state.serviceList;
    }
    return state.serviceList.filter(service => service.categoryId === Number(categoryId));
  },
  
  /**
   * 按评分获取评价列表
   * @param {ServiceState} state - 状态
   * @returns {Function} 返回一个函数，接收评分参数返回过滤后的评价列表
   */
  reviewsByRating: (state) => (rating) => {
    if (rating === SERVICE_RATING.ALL) {
      return state.reviews;
    } else if (rating === SERVICE_RATING.GOOD) {
      return state.reviews.filter(review => review.rating >= 4);
    } else if (rating === SERVICE_RATING.MEDIUM) {
      return state.reviews.filter(review => review.rating === 3);
    } else if (rating === SERVICE_RATING.BAD) {
      return state.reviews.filter(review => review.rating <= 2);
    }
    return state.reviews;
  },
  
  /**
   * 获取有图评价
   * @param {ServiceState} state - 状态
   * @returns {Array} 有图评价列表
   */
  reviewsWithImages: (state) => {
    return state.reviews.filter(review => review.images && review.images.length > 0);
  },
  
  /**
   * 获取当前服务的评分统计
   * @param {ServiceState} state - 状态
   * @returns {Object} 评分统计对象
   */
  reviewStats: (state) => {
    const stats = {
      all: state.reviews.length,
      good: 0,
      medium: 0,
      bad: 0,
      withImages: 0
    };
    
    state.reviews.forEach(review => {
      if (review.rating >= 4) {
        stats.good++;
      } else if (review.rating === 3) {
        stats.medium++;
      } else {
        stats.bad++;
      }
      
      if (review.images && review.images.length > 0) {
        stats.withImages++;
      }
    });
    
    return stats;
  }
};

/**
 * 服务模块导出
 * @type {Object}
 */
export default {
  namespaced: true,
  state,
  mutations,
  actions,
  getters
};
